var _n57;
var cc__extends = __extends;
var cc__createBinding = __createBinding;
var cc__setModuleDefault = __setModuleDefault;
var cc__importStar = __importStar;
var cc__awaiter = __awaiter;
var cc__generator = __generator;
var cc__importDefault = __importDefault;
Object.defineProperty(exports, "__esModule", {
  value: true
});
var $1$zqcc_frameNamespace = require("zqcc_frameNamespace");
var p = cc__importDefault($1$zqcc_frameNamespace);
var $1$gameMode_Json = require("gameMode_Json");
var d = cc__importDefault($1$gameMode_Json);
var $1$zqcc_OverallSystem = require("zqcc_OverallSystem");
var h = cc__importStar($1$zqcc_OverallSystem);
var def_gameManager = function (t) {
  function _ctor() {
    // 调用t函数并获取上下文，若无返回当前对象
    var context = t.call(this) || this;

    // 设置管理名
    context._managerName = "游戏管理";

    // 初始化当前模式为未定义
    context.m_CurrMode = undefined;

    // 调用初始化方法
    context._Initialize();

    // 返回上下文对象
    return context;
  }
  cc__extends(_ctor, t);
  _ctor.prototype._Initialize = function () {
    t.prototype._Initialize.call(this);
  };
  _ctor.prototype.openPhysics = function (t, e) {
    // 如果t未定义，设为false
    undefined === t && (t = false);

    // 如果e未定义，设为true
    undefined === e && (e = true);

    // 启用物理管理器
    cc.director.getPhysicsManager().enabled = true;

    // 如果e为true，则设置帧率为60
    if (e) {
      cc.game.setFrameRate(60);
    }
  };
  _ctor.prototype.openPhysicsDebugDrawFlags = function (t) {
    undefined === t && (t = false);
    if (t) {
      cc.director.getPhysicsManager().debugDrawFlags = cc.PhysicsManager.DrawBits.e_jointBit | cc.PhysicsManager.DrawBits.e_shapeBit;
    }
  };
  _ctor.prototype.openCollision = function (t) {
    undefined === t && (t = false);
    cc.director.getCollisionManager().enabled = t;
  };
  _ctor.prototype.openCollisionDebugDraw = function (t) {
    undefined === t && (t = false);
    cc.director.getCollisionManager().enabledDebugDraw = t;
  };
  _ctor.prototype.openDebugFPS = function (t) {
    undefined === t && (t = false);
    cc.debug.setDisplayStats(t);
  };
  Object.defineProperty(_ctor.prototype, "currMode", {
    get() {
      return this.m_CurrMode;
    },
    enumerable: false,
    configurable: true
  });
  _ctor.prototype.enterMode = function (t, e) {
    // 如果e未定义，设为true
    undefined === e && (e = true);

    // 返回一个异步函数
    return cc__awaiter(this, undefined, undefined, function () {
      var bundleResource;
      var context = this; // 保存当前上下文
      return cc__generator(this, function (i) {
        switch (i.label) {
          case 0:
            // 如果e为true，显示加载界面
            e && h.sers().uiSrv.showLoding();

            // 获取当前模式
            bundleResource = d.default()[t];
            console.time("进入模式耗时---" + bundleResource.explain);
            this.m_CurrMode = bundleResource;

            // 检查模式的bundle条件
            if (bundleResource.bundle || !bundleResource.bundleName || bundleResource.bundleName === "") {
              return [3, 2]; // 直接跳转到下一步
            } else {
              console.log("加载模式所需资源bundle---", bundleResource.bundleName);
              return [4, new Promise(function (resolve, reject) {
                cc.assetManager.loadBundle(bundleResource.bundleName, function (err, bundle) {
                  if (err) {
                    console.error("进入模式 :" + bundleResource.explain + ",  加载所需bundle失败", err);
                    return void reject();
                  }
                  bundleResource.bundle = bundle; // 保存加载的资源包
                  // 预加载场景
                  cc.director.preloadScene(bundleResource.sceneName);
                  context.goToNeedEnterMode().then(resolve); // 进入模式
                });
              })];
            }
          case 1:
            i.sent(); // 等待Promise解析
            return [3, 3]; // 继续到下一步
          case 2:
            return [2, this.goToNeedEnterMode()]; // 直接进入模式
          case 3:
            return [2]; // 返回完成
        }
      });
    });
  };
  _ctor.prototype.goToNeedEnterMode = function () {
    // 返回一个异步函数
    return cc__awaiter(this, undefined, undefined, function () {
      return cc__generator(this, function (t) {
        switch (t.label) {
          case 0:
            // 关闭当前场景页面
            h.sers().uiSrv._closeCurrScenePage();
            // 加载当前模式的场景
            return [4, h.default.loadScene(this.m_CurrMode.sceneName)];
          case 1:
            t.sent(); // 等待场景加载完成
            // 隐藏加载界面
            h.sers().uiSrv.hideLoding();
            console.timeEnd("进入模式耗时---" + this.m_CurrMode.explain); // 输出进入模式的耗时
            return [2]; // 返回完成
        }
      });
    });
  };
  _ctor.prototype.getCurrModeBundle = function () {
    var currentMode = this.m_CurrMode;

    // 检查当前模式是否为null或undefined
    if (currentMode === null || currentMode === undefined) {
      return undefined; // 如果是，返回undefined
    } else {
      return currentMode.bundle; // 否则，返回当前模式的bundle
    }
  };
  _ctor.prototype.backHomePage = function () {
    // 将当前模式设置为未定义
    this.m_CurrMode = undefined;

    // 关闭当前场景页面
    h.sers().uiSrv._closeCurrScenePage();

    // 加载主页场景
    h.default.loadScene("home").then(function () {
      // 场景加载完成后隐藏加载界面
      h.sers().uiSrv.hideLoding();
    });

    // 输出日志信息
    console.log("返回主页");
  };
  _ctor.prototype.enableMultiTouch = function (t) {
    undefined === t && (t = true);
    cc.macro.ENABLE_MULTI_TOUCH = t;
  };
  return _ctor;
}(p.default.zqcc_ManagerBase);
exports.default = def_gameManager;